#ifndef MY_UTIL_HPP
#define MY_UTIL_HPP

#include "logger.hpp"
#include <string>
#include <iostream>
#include <mysql/mysql.h>
#include <jsoncpp/json/json.h>
#include <memory>
#include <sstream>
#include <vector>
#include <fstream>
#include <websocketpp/server.hpp>
#include <websocketpp/config/asio_no_tls.hpp>

typedef websocketpp::server<websocketpp::config::asio> wssrv_t;

//实用工具类模块
class mysql_util
{
public:
    static MYSQL* mysql_create(const std::string& host,const std::string& user, 
        const std::string& passwd, 
        const std::string& dbname, unsigned int port = 3306)
    {
        //1.初始化mysql句柄
        //这里为空，表示由系统在堆上面申请空间创建MYSQL对象
        MYSQL* mysql = mysql_init(NULL);
        if(mysql == NULL)
        {
            ELOG("mysql init fail");
            return nullptr;
        }

        //2.连接服务器
        if(mysql_real_connect(mysql, host.c_str(), user.c_str(), passwd.c_str(), dbname.c_str(), port, NULL, 0) == NULL)
        {
            ELOG("mysql connect fail, error: %s", mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }

        //3.设置客户端字符集
        if(mysql_set_character_set(mysql, "utf8mb4") != 0)
        {
            ELOG("set client character fail, error: %s", mysql_error(mysql));
            mysql_close(mysql);
            return nullptr;
        }

        return mysql;
    }

    static bool mysql_exec(MYSQL* mysql, const std::string& sql)
    {
        
        if(mysql_query(mysql, sql.c_str()) != 0)
        {
            ELOG("%s", sql.c_str());
            ELOG("mysql query fail, error: %s", mysql_error(mysql));
            return false;
        }
        return true;
    }

    static void mysql_destory(MYSQL* mysql)
    {
        if(mysql != nullptr)
            mysql_close(mysql);
        return;
    }
};

class json_util
{
public:
    //序列化
    static bool serialize(const Json::Value& root, std::string& str)
    {
        Json::StreamWriterBuilder swb;
        //这里防止所有非ASCII字符（包括中文）被转义为 \uXXXX 格式
        //保证原始的格式,便于调试
        swb.settings_["emitUTF8"] = true;
        std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
        std::stringstream ss;
        int ret = sw->write(root, &ss);

        if(ret != 0)
        {
            ELOG("json serialize fail");
            return false;
        }
        str = ss.str();
        return true;
    }

    //反序列化
    static bool unserialize(const std::string& str, Json::Value& root)
    {
        Json::CharReaderBuilder crb;
        std::unique_ptr<Json::CharReader> cr(crb.newCharReader());

        std::string error;
        int ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &error);
        if(ret == false)
        {
            ELOG("json unserialize fail %s", error.c_str());
            return false;
        }
        return true;
    }
};

class string_util
{
public:
    static int spilt(const std::string& src, std::string sep, std::vector<std::string>& res)
    {
        //123,456,789,,,100
        int pos = 0;
        int index = 0;

        while(index < src.size())
        {
            pos = src.find(sep, index);
            //只有一个 "111"
            if(pos == std::string::npos)
            {   
                res.push_back(src.substr(index));
                break;
            }
            //遇见连续相同的分割符 "2,,,1"
            if(pos == index)
            {
                index += sep.size();
                continue;
            }

            res.push_back(src.substr(index, pos - index));
            index = pos + sep.size();
        }
        return res.size();
    }
};

class file_util
{
public:
    static bool read(const std::string& filename, std::string& body)
    {
        //打开文件
        //以二进制打开
        std::ifstream ifs(filename, std::ios::binary);
        //检查文件是否成功打开
        if(ifs.is_open() == false)
        {
            ELOG("%s file open fail", filename.c_str());
            return false;
        }

        //获取文件大小
        //将文件指针移动到文件末尾
        ifs.seekg(0, std::ios::end);
        //该文件指针距离文件开始位置的大小
        int fsize = ifs.tellg();
        //将文件指针重新移动到文件开头，准备读取
        ifs.seekg(0, std::ios::beg);

        body.resize(fsize);
        //从文件获取数据
        ifs.read(&body[0], fsize);
        //检查读取操作是否成功完成
        //这个good 作用：检查流是否处于"良好"状态，即没有任何错误发生
        if(ifs.good() == false)
        {
            ELOG("read %s file content fail", filename.c_str());
            ifs.close();
            return false;
        }

        //关闭文件
        ifs.close();
        return true;
    }
};

#endif